{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Download Imdb data from\n",
    " http://mng.bz/0tIo\n",
    "\n",
    "let’s collect the individual training reviews into a list of strings, one string per\n",
    "review. We’ll also collect the review labels (positive/negative) into a labels list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['.DS_Store', 'test', 'train']\n",
      "['.DS_Store', 'neg', 'pos', 'urls_neg.txt', 'urls_pos.txt']\n"
     ]
    }
   ],
   "source": [
    "# Lets take a look at the downloaded dada\n",
    "\n",
    "import os\n",
    "\n",
    "print(os.listdir('aclImdb'))\n",
    "print(os.listdir('aclImdb/train'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# IMDB Dataset contain negative and positive reviews in text format "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I loved Dedee Pfeiffer (is that spelled right?) in Cybil. Haven't seen her for awhile and forgot how much I missed her. I thought she did a great job in this. The supporting cast was pretty good too. In some angles, the daughter even looked like a young Nicole Kidman. The abductor was pretty creepy and the story generally had some good twists. The young boyfriend was a hottie. I thought the husband definitely had something to do with it for sure.<br /><br />Just got the Lifetime Movie Network for Christmas and am loving these movies. Kept my interest and I'll watch it again when they rerun it. Can anyone else recommend any similar movies to this? You can post on the board or send me a private email if you want. Thanks in advance. Aboutagirly.\n"
     ]
    }
   ],
   "source": [
    "f = open(\"aclImdb/train/pos/268_8.txt\", \"r\")\n",
    "print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorry everyone,,, I know this is supposed to be an \"art\" film,, but wow, they should have handed out guns at the screening so people could blow their brains out and not watch. Although the scene design and photographic direction was excellent, this story is too painful to watch. The absence of a sound track was brutal. The loooonnnnng shots were too long. How long can you watch two people just sitting there and talking? Especially when the dialogue is two people complaining. I really had a hard time just getting through this film. The performances were excellent, but how much of that dark, sombre, uninspired, stuff can you take? The only thing i liked was Maureen Stapleton and her red dress and dancing scene. Otherwise this was a ripoff of Bergman. And i'm no fan f his either. I think anyone who says they enjoyed 1 1/2 hours of this is,, well, lying.\n"
     ]
    }
   ],
   "source": [
    "f = open(\"aclImdb/train/neg/10002_1.txt\", \"r\")\n",
    "print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Processing the labels of the raw IMDB data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# With this entire code we just created labels for the neg and pos text\n",
    "\n",
    "import os\n",
    "imdb_dir = 'aclImdb'\n",
    "train_dir = os.path.join(imdb_dir, 'train') #train_dir = aclImdb\\train\n",
    "labels = []\n",
    "texts = []\n",
    "for label_type in ['neg', 'pos']:\n",
    "    dir_name = os.path.join(train_dir, label_type) #dir_name = aclImdb\\train\\neg\n",
    "                                                   #dir_name = aclImdb\\train\\pos\n",
    "        \n",
    "    for fname in os.listdir(dir_name):\n",
    "        if fname[-4:] == '.txt':                  # if file is text file\n",
    "            f = open(os.path.join(dir_name, fname),encoding=\"utf8\") # open it\n",
    "            texts.append(f.read())               # add in that empty texts list we made before\n",
    "            f.close()\n",
    "        if label_type == 'neg':                 # ager neg folder ka ho to 0 label\n",
    "            labels.append(0)                    # aur labels list mai daldo jo upper bnaya tha\n",
    "        else:\n",
    "            labels.append(1)                   # pos hoto 1 label deke labels folder mai daldo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tokenizing the text of the raw IMDB data\n",
    "we’ll add the following twist:\n",
    "restricting the training data to the first 200 samples. So you’ll learn to classify movie\n",
    "reviews after looking at just 200 examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "maxlen = 100               # Cuts off reviews after 100 words\n",
    "training_samples = 200     # Trains on 200 samples\n",
    "validation_samples = 10000 # Validates on 10,000 samples\n",
    "max_words = 10000          # Considers only the top 10,000 words in the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "\n",
    "tokenizer = Tokenizer(num_words=max_words)    # max_words = 10000 \n",
    "tokenizer.fit_on_texts(texts)\n",
    "sequences = tokenizer.texts_to_sequences(texts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 88582 unique tokens.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "word_index = tokenizer.word_index\n",
    "print('Found %s unique tokens.' % len(word_index))\n",
    "print()\n",
    "#print(tokenizer.word_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pad_sequences is used to ensure that all sequences in a list have the same length.\n",
    "\n",
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "data = pad_sequences(sequences, maxlen=maxlen)                    # maxlen = 100   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of data tensor: (25000, 100)\n",
      "Shape of label tensor: (25000,)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "labels = np.asarray(labels)\n",
    "print('Shape of data tensor:', data.shape)\n",
    "print('Shape of label tensor:', labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# randomizing data\n",
    "\n",
    "indices = np.arange(data.shape[0])   # same length ke range bnai \n",
    "np.random.shuffle(indices)           # uske position shuffle ke\n",
    "data = data[indices]                 # same shuffle position data ke bhe kerde\n",
    "labels = labels[indices]             # aur label ke bhe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(200, 100)\n",
      "(200,)\n",
      "(10000, 100)\n",
      "(10000,)\n"
     ]
    }
   ],
   "source": [
    "# spliting data\n",
    "\n",
    "x_train = data[:training_samples]  # training_samples = 200 \n",
    "y_train = labels[:training_samples]\n",
    "x_val = data[training_samples: training_samples + validation_samples] # validation_samples = 10000\n",
    "y_val = labels[training_samples: training_samples + validation_samples]\n",
    "\n",
    "print(x_train.shape)\n",
    "print(y_train.shape)\n",
    "print(x_val.shape)\n",
    "print(y_val.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DOWNLOAD THE GLOVE WORD EMBEDDINGS\n",
    "Its a pretrained Word Embedding : \n",
    "https://nlp.stanford.edu/projects/glove\n",
    "\n",
    "It’s an 822 MB zip file called glove.6B.zip,\n",
    "containing 100-dimensional embedding vectors for 400,000 words (or nonword\n",
    "tokens).\n",
    "\n",
    "PREPROCESSING THE EMBEDDINGS\n",
    "Let’s parse the unzipped file (a .txt file) to build an index that maps words (as strings)\n",
    "to their vector representation (as number vectors)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parsing the GloVe word-embeddings file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Folder contain : ['glove.6B.100d.txt', 'glove.6B.200d.txt', 'glove.6B.300d.txt', 'glove.6B.50d.txt']\n",
      "\n",
      "Printing first value :\n",
      "\n",
      " ['sandberger', '0.28365', '-0.6263', '-0.44351', '0.2177', '-0.087421', '-0.17062', '0.29266', '-0.024899', '0.26414', '-0.17023', '0.25817', '0.097484', '-0.33103', '-0.43859', '0.0095799', '0.095624', '-0.17777', '0.38886', '0.27151', '0.14742', '-0.43973', '-0.26588', '-0.024271', '0.27186', '-0.36761', '-0.24827', '-0.20815', '0.22128', '-0.044409', '0.021373', '0.24594', '0.26143', '0.29303', '0.13281', '0.082232', '-0.12869', '0.1622', '-0.22567', '-0.060348', '0.28703', '0.11381', '0.34839', '0.3419', '0.36996', '-0.13592', '0.0062694', '0.080317', '0.0036251', '0.43093', '0.01882', '0.31008', '0.16722', '0.074112', '-0.37745', '0.47363', '0.41284', '0.24471', '0.075965', '-0.51725', '-0.49481', '0.526', '-0.074645', '0.41434', '-0.1956', '-0.16544', '-0.045649', '-0.40153', '-0.13136', '-0.4672', '0.18825', '0.2612', '0.16854', '0.22615', '0.62992', '-0.1288', '0.055841', '0.01928', '0.024572', '0.46875', '0.2582', '-0.31672', '0.048591', '0.3277', '-0.50141', '0.30855', '0.11997', '-0.25768', '-0.039867', '-0.059672', '0.5525', '0.13885', '-0.22862', '0.071792', '-0.43208', '0.5398', '-0.085806', '0.032651', '0.43678', '-0.82607', '-0.15701']\n"
     ]
    }
   ],
   "source": [
    "# lets check the downloaded glove file\n",
    "\n",
    "import os\n",
    "print(\"Folder contain :\",os.listdir(\"glove.6B\"))\n",
    "print()\n",
    "\n",
    "# each file colntain word with its vextor lets check\n",
    "\n",
    "f = open('glove.6B/glove.6B.100d.txt',encoding=\"utf8\")\n",
    "for i in f:\n",
    "    values = i.split()\n",
    "f.close()\n",
    "print(\"Printing first value :\\n\\n\",values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 400000 word vectors.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# lets put the same format in a dictionary\n",
    "\n",
    "glove_dir = 'glove.6B'                                                   \n",
    "embeddings_index = {}\n",
    "f = open(os.path.join(glove_dir, 'glove.6B.100d.txt'),encoding=\"utf8\")\n",
    "\n",
    "for line in f:\n",
    "    values = line.split()\n",
    "    word = values[0]\n",
    "    coefs = np.asarray(values[1:], dtype='float32')\n",
    "    embeddings_index[word] = coefs\n",
    "f.close()\n",
    "print('Found %s word vectors.' % len(embeddings_index))\n",
    "print()\n",
    "#print(embeddings_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, you’ll build an embedding matrix that you can load into an Embedding layer. It\n",
    "must be a matrix of shape (max_words, embedding_dim), where each entry i contains\n",
    "the embedding_dim-dimensional vector for the word of index i in the reference word\n",
    "index (built during tokenization). Note that index 0 isn’t supposed to stand for any\n",
    "word or token—it’s a placeholder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preparing the GloVe word-embeddings matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we have\n",
    "# print(word_index) # word and its number (built during tokenization) in dict format\n",
    "\n",
    "# and we have\n",
    "# print(embeddings_index) # word and its vector (Gloves) in dict format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 100)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# ab hum embeding matrix bnainge jise embeding layer mai dalsake\n",
    "# word tokinizer wala ho aue uska vector glove wala\n",
    "\n",
    "# zero ke matrix bnaya\n",
    "\n",
    "# max_words = 10000\n",
    "embedding_dim = 100\n",
    "\n",
    "embedding_matrix = np.zeros((max_words, embedding_dim))\n",
    "\n",
    "print(embedding_matrix.shape)\n",
    "print()\n",
    "#print(embedding_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 100)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for word, i in word_index.items():\n",
    "    if i < max_words:   # 10000 index uthai tokinizer ke\n",
    "        embedding_vector = embeddings_index.get(word) # aur gloves ka vector usay dedo\n",
    "        if embedding_vector is not None: # aur word na mile embading mai to zero ka bnado\n",
    "            embedding_matrix[i] = embedding_vector # embedding_matrix mai save kerdo\n",
    "\n",
    "# ab hamare pass tokinizer wale value ke vector bhe hai embedding_matrix mai\n",
    "print(embedding_matrix.shape)\n",
    "print()\n",
    "#print(embedding_matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model definition\n",
    "We’ll use the same model architecture as before. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding (Embedding)        (None, 100, 100)          1000000   \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 10000)             0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 32)                320032    \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 1)                 33        \n",
      "=================================================================\n",
      "Total params: 1,320,065\n",
      "Trainable params: 1,320,065\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Embedding, Flatten, Dense\n",
    "model = Sequential()\n",
    "model.add(Embedding(max_words, embedding_dim, input_length=maxlen))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(32, activation='relu'))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading pretrained word embeddings into the Embedding layer\n",
    "The Embedding layer has a single weight matrix: a 2D float matrix where each entry i is\n",
    "the word vector meant to be associated with index i. Simple enough. Load the GloVe\n",
    "matrix you prepared into the Embedding layer, the first layer in the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.layers[0].set_weights([embedding_matrix]) # pretrained use kare\n",
    "model.layers[0].trainable = False               # aur usko freeze kerdia ke mazed train na ho"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, you’ll freeze the Embedding layer (set its trainable attribute to False),\n",
    "following the same rationale you’re already familiar with in the context of pretrained\n",
    "convnet features: when parts of a model are pretrained (like your Embedding layer)\n",
    "and parts are randomly initialized (like your classifier), the pretrained parts shouldn’t\n",
    "be updated during training, to avoid forgetting what they already know. The large gradient updates triggered by the randomly initialized layers would be disruptive to the\n",
    "already-learned features. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training and evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 200 samples, validate on 10000 samples\n",
      "Epoch 1/10\n",
      "200/200 [==============================] - 3s 16ms/sample - loss: 1.5624 - acc: 0.5000 - val_loss: 0.6917 - val_acc: 0.4946\n",
      "Epoch 2/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.6345 - acc: 0.6600 - val_loss: 0.9594 - val_acc: 0.5073\n",
      "Epoch 3/10\n",
      "200/200 [==============================] - 2s 11ms/sample - loss: 0.7499 - acc: 0.6650 - val_loss: 0.7998 - val_acc: 0.5262\n",
      "Epoch 4/10\n",
      "200/200 [==============================] - 2s 9ms/sample - loss: 0.3650 - acc: 0.8300 - val_loss: 0.8181 - val_acc: 0.5472\n",
      "Epoch 5/10\n",
      "200/200 [==============================] - 2s 9ms/sample - loss: 0.2617 - acc: 0.8950 - val_loss: 0.7696 - val_acc: 0.5353\n",
      "Epoch 6/10\n",
      "200/200 [==============================] - 2s 9ms/sample - loss: 0.2819 - acc: 0.8700 - val_loss: 0.9572 - val_acc: 0.5345\n",
      "Epoch 7/10\n",
      "200/200 [==============================] - 2s 9ms/sample - loss: 0.1049 - acc: 0.9750 - val_loss: 1.1792 - val_acc: 0.4988\n",
      "Epoch 8/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.0717 - acc: 1.0000 - val_loss: 1.3338 - val_acc: 0.5177\n",
      "Epoch 9/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.0808 - acc: 0.9900 - val_loss: 0.8725 - val_acc: 0.5517\n",
      "Epoch 10/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.0210 - acc: 1.0000 - val_loss: 0.7917 - val_acc: 0.5747\n"
     ]
    }
   ],
   "source": [
    "model.compile(optimizer='rmsprop',\n",
    "loss='binary_crossentropy',\n",
    "metrics=['acc'])\n",
    "\n",
    "history = model.fit(x_train, y_train,\n",
    "                    epochs=10,\n",
    "                    batch_size=32,\n",
    "                    validation_data=(x_val, y_val))\n",
    "\n",
    "model.save_weights('pre_trained_glove_model.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting the results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "epochs = range(1, len(acc) + 1)\n",
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "plt.figure()\n",
    "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model quickly starts overfitting, which is unsurprising given the small number of\n",
    "training samples. Validation accuracy has high variance for the same reason, but it\n",
    "seems to reach the high 50s.\n",
    " Note that your mileage may vary: because you have so few training samples, performance is heavily dependent on exactly which 200 samples you choose—and you’re\n",
    "choosing them at random. If this works poorly for you, try choosing a different random set of 200 samples, for the sake of the exercise (in real life, you don’t get to\n",
    "choose your training data).\n",
    " You can also train the same model without loading the pretrained word embeddings and without freezing the embedding layer. In that case, you’ll learn a taskspecific embedding of the input tokens, which is generally more powerful than\n",
    "pretrained word embeddings when lots of data is available. But in this case, you have\n",
    "only 200 training samples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training the same model without pretrained word embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ab pretrained word embeding use nahe ker rahe\n",
    "# apne bna rahe hai aur freeze bhe nahe ker rahe\n",
    "# jese pichle example mai kia tha\n",
    "# but data humne kam lia hai sirf 200 to performance ache nahe hoge "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_1 (Embedding)      (None, 100, 100)          1000000   \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 10000)             0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 32)                320032    \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 1)                 33        \n",
      "=================================================================\n",
      "Total params: 1,320,065\n",
      "Trainable params: 1,320,065\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Train on 200 samples, validate on 10000 samples\n",
      "Epoch 1/10\n",
      "200/200 [==============================] - 3s 13ms/sample - loss: 0.6897 - acc: 0.5150 - val_loss: 0.6941 - val_acc: 0.5205\n",
      "Epoch 2/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.4705 - acc: 0.9700 - val_loss: 0.7022 - val_acc: 0.5232\n",
      "Epoch 3/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.2501 - acc: 0.9950 - val_loss: 0.7058 - val_acc: 0.5256\n",
      "Epoch 4/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.1032 - acc: 1.0000 - val_loss: 0.7068 - val_acc: 0.5271\n",
      "Epoch 5/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.0496 - acc: 1.0000 - val_loss: 0.7107 - val_acc: 0.5305\n",
      "Epoch 6/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.0251 - acc: 1.0000 - val_loss: 0.7189 - val_acc: 0.5331\n",
      "Epoch 7/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.0139 - acc: 1.0000 - val_loss: 0.7253 - val_acc: 0.5313\n",
      "Epoch 8/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.0082 - acc: 1.0000 - val_loss: 0.7361 - val_acc: 0.5313\n",
      "Epoch 9/10\n",
      "200/200 [==============================] - 2s 10ms/sample - loss: 0.0049 - acc: 1.0000 - val_loss: 0.7370 - val_acc: 0.5339\n",
      "Epoch 10/10\n",
      "200/200 [==============================] - 2s 9ms/sample - loss: 0.0030 - acc: 1.0000 - val_loss: 0.7475 - val_acc: 0.5339\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Embedding, Flatten, Dense\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Embedding(max_words, embedding_dim, input_length=maxlen))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(32, activation='relu'))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "model.summary()\n",
    "\n",
    "model.compile(optimizer='rmsprop',\n",
    "loss='binary_crossentropy',\n",
    "metrics=['acc'])\n",
    "\n",
    "history = model.fit(x_train, y_train,\n",
    "                    epochs=10,\n",
    "                    batch_size=32,\n",
    "                    validation_data=(x_val, y_val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "acc = history.history['acc']\n",
    "val_acc = history.history['val_acc']\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']\n",
    "epochs = range(1, len(acc) + 1)\n",
    "plt.plot(epochs, acc, 'bo', label='Training acc')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
    "plt.title('Training and validation accuracy')\n",
    "plt.legend()\n",
    "plt.figure()\n",
    "plt.plot(epochs, loss, 'bo', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Validation accuracy stalls in the low 50s. So in this case, pretrained word embeddings\n",
    "outperform jointly learned embeddings. If you increase the number of training samples, this will quickly stop being the case—try it as an exercise.\n",
    "\n",
    " Finally, let’s evaluate the model on the test data. First, you need to tokenize the test\n",
    "data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tokenizing the data of the test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# With this entire code we just created labels for the neg and pos text\n",
    "\n",
    "import os\n",
    "imdb_dir = 'aclImdb'\n",
    "test_dir = os.path.join(imdb_dir, 'test') #test_dir = aclImdb\\test\n",
    "labels = []\n",
    "texts = []\n",
    "for label_type in ['neg', 'pos']:\n",
    "    dir_name = os.path.join(test_dir, label_type) #dir_name = aclImdb\\test\\neg\n",
    "                                                   #dir_name = aclImdb\\test\\pos\n",
    "        \n",
    "    for fname in os.listdir(dir_name):\n",
    "        if fname[-4:] == '.txt':                  # if file is text file\n",
    "            f = open(os.path.join(dir_name, fname),encoding=\"utf8\") # open it\n",
    "            texts.append(f.read())               # add in that empty texts list we made before\n",
    "            f.close()\n",
    "        if label_type == 'neg':                 # ager neg folder ka ho to 0 label\n",
    "            labels.append(0)                    # aur labels list mai daldo jo upper bnaya tha\n",
    "        else:\n",
    "            labels.append(1)                   # pos hoto 1 label deke labels folder mai daldo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "sequences = tokenizer.texts_to_sequences(texts) # number me convert kia\n",
    "x_test = pad_sequences(sequences, maxlen=maxlen) # sentence ke max length set ke\n",
    "y_test = np.asarray(labels) # labels ko array mai convert kia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, load and evaluate the first model.\n",
    "pretrained Glove embeding wala"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluating the model on the test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25000/1 - 4s - loss: 0.6767 - acc: 0.5726\n",
      "\n",
      "Loss:  80.43322939109802 %\n",
      "Accuracy:  57.256001234054565 %\n"
     ]
    }
   ],
   "source": [
    "model.load_weights('pre_trained_glove_model.h5')\n",
    "\n",
    "evaluation = model.evaluate(x_test,y_test,verbose=2)\n",
    "print()\n",
    "print(\"Loss: \",evaluation[0]*100,\"%\")\n",
    "print(\"Accuracy: \",evaluation[1]*100,\"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You get an appalling test accuracy of 56%. Working with just a handful of training\n",
    "samples is difficult!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wrapping up\n",
    "Now you’re able to do the following:\n",
    "\n",
    " Turn raw text into something a neural network can process\n",
    "\n",
    " Use the Embedding layer in a Keras model to learn task-specific token embeddings\n",
    "\n",
    " Use pretrained word embeddings to get an extra boost on small naturallanguage-processing problems"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_gpu",
   "language": "python",
   "name": "conda_gpu"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
